bondscell_results$bcc0cb23-ea14-477c-8e3c-2c04d7fd00d8queued¤logsrunning¦outputbody.Object-Oriented Behaviour
Object-oriented languages tightly couple the class (or composite type) and the method (or function). This is achieved via single dispatch, which means that only the first argument is used to detemine which function to call or execute. Python is a good example of a single dispatch language.
For Python, the method may look like the following, where self is the class (composite type):
def mymethod(self, a, b):
The method is usually invoked using the dot notation:
self.mymethod(a, b)
Julia loosely couples composite types (classes) and functions (methods) because of multiple dispatach, which means that all positional arguments, or type signature, are used to determine which function to call or execute. Therefore, Julia is not an object-oriented language.
1-6: Functions and Types
Last Updated: 1 Jul 2026
mimetext/htmlrootassigneelast_run_timestampAڑ^(ppersist_js_state÷has_pluto_hook_features§cell_id$5c195e5e-3929-4448-9b6e-f3b989f2e297depends_on_disabled_cells§runtime 1Dpublished_object_keysdepends_on_skipped_cells§errored$dbf2d122-5751-447e-9a6b-6997fe9a07fcqueued¤logsrunning¦outputbodyConstructor Functions
Functions can be constructors for composite types. Assume a composite type MyType has two fields a and b:
struct MyType
a::Integer
b::Integer
end
Julia automatically creates a default constructor function:
function MyType(a::Integer, b::Integer)
new(a, b)
end
with usage of:
MyType(1, 3)
Now assume the second argument b is often 0, then we can define a function of the same name with the second argument having a default value of 0.
function MyType(a::Integer, b::Integer=0)
MyType(a, b)
end
with usage of:
MyType(1)
1: A function with one abstract type
Create a function having one argument being an abstract float type.
Use the function with a Float64 (double precision) type, e.g., 1.0 or 1.0e0.
Use the function with a Float32 (single precision) type, e.g., 1.0f0.
How many methods does it have?
Use the function with a BigFloat type.
How many methods are there now?
Let Julia Do It
Let's assume that we have to write a function myfunc to do some data analysis. The function has one argument a. It has the same implementation for all floating point data types.
For statically compiled languages such as C, each argument type must have its own version of the function, i.e., myfunc(a::Float32), myfunc(a::Float64), etc.
For interpreted languages such as Python, only one version is needed, but performance suffers because the interpreter must determine the type of the argument.
For Julia, only one version of the function is needed, assuming the argument type is an AbstractFloat, i.e., myfunc(a::AbstractFloat)
AbstractFloat tells Julia to only allow floating point types for the argument. Integers or Strings are not allowed. A new version or method of the function is compiled for each new data type. Thus, the user only needs to write one version of the function. Julia will create new versions of the function for each new argument type when needed.
This feature makes Julia a very productive language by reducing the number of lines of code that need to be written. Julia is typically twice as productive as Python and ten times as productive as C/C++ with similar or better performance.
Note
Productivity is inversely proportional to the number of lines of code. Fewer lines of code result in greater productivity.
4: Object-oriented behaviour
Overload the add operator by executing import Base.+ .
Create a 2D point type.
Create a variable using the Point type.
Create add function for the Point type.
How many methods does the Base.+ function have?
Add the two points together, e.g., Point(1, 2) + Point(3, 4).
Create a norm function for the Point type.
Evaluate the norm for a point.
3: A constructor function
Create a composite type with two fields.
Instantiate the type, e.g., a = MyType(1, 2).
Create a function of the same name having a default second argument.
Use the function with one and two arguments.
Summary
Abstract types allow you to write functions for a specific set of types.
Julia creates a new version of the function based on the argument types.
Functions can be used to simplify composite type constructors.
Julia is not an object-oriented language, but is behaves like one.
Functors are nameless functions that use the composite type for dispatch.
Problems
Remember that you can get help either through `?` in a REPL or with "Live Docs" right here in Pluto (lower right-hand corner)
2: A function with two abstract types
Create a add function having two arguments, the first being an abstract float and the second an abstract integer.
Use the function with float and integer arguments.
Use the function with integer and float arguments.
Functors
Functors are nameless functions. They are defined by their argument type, usually a composite type. A good example of this behaviour is the polynomial.
Construct the polynomial type:
struct Polynomial{R}
coef::Vector{R}
end
Construct the function to evaluate the polynomial:
function (p::Polynomial)(x)
...
end
Create the polynomial:
p = Polynomial([1, 2, 3])
Evaluate the polynomial
p(3)